#include "../source/server.hpp"
//#include "server.hpp"
//#include "server1.hpp"
//#include "server2.hpp"
//#include "demoserver.hpp"


//管理所有连接
std::unordered_map<uint64_t,PtrConnection> _conns;
uint64_t conn_id=0;
//EventLoop loop;
//loop线程测试
EventLoop baseloop;//主线程Loop
// std::vector<LoopThread> threads(2);
// int next_thread=0;
//Loop线程池测试
LoopThreadPool pool(&baseloop);//可以设置

// void ConnectionDestory(const PtrConnection &conn){
//     //_conns.erase(conn->Id());
//     //conn->Shutdown();
//     DEBUG_LOG("Close CONNECTION:%p:",conn.get());
// }

void OnClosed(const PtrConnection &conn){
    //_conns.erase(conn->Id());
    //conn->Shutdown();
    DEBUG_LOG("Close CONNECTION:%p:",conn.get());
}

void OnConnected(const PtrConnection &conn){
    DEBUG_LOG("NEW CONNECTION:%p:",conn.get());
}

void OnMessage(const PtrConnection &conn,Buffer*buf){
    //读出输入缓冲区中的数据进行处理
    DEBUG_LOG("%s",buf->ReadPosition());
    buf->MoveReadOffset(buf->ReadAbleSize());
    //将处理后的结果写到发送缓冲区中
    std::string data("Hello World!!!");
    conn->Send((char*)data.c_str(),data.size());
    //conn->Shutdown();
    //DEBUG_LOG("发送数据");
}

//使用Connection管理套接字
//线程管理
// void NewConnection(int newfd){
//     conn_id++; 
//     PtrConnection new_conn(new Connection(pool.GetLoop(),conn_id,newfd));
//     //我们调用时都是自己传的参数，在这里不需要直接设定
//     new_conn->SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));
//     new_conn->SetClosedCallback(std::bind(ConnectionDestory,std::placeholders::_1));
//     new_conn->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1));
//     //new_conn->SetAnyEventCallback(std::bind(HandleEvent,new_conn));//任意事件回调都需要刷新时间
    
//     new_conn->EnableInactiveRelease(10);
//     new_conn->Established();//
//     _conns.insert(std::make_pair(conn_id,new_conn));
//     //DEBUG_LOG("GET A NEW CONNECTION fd:%d",newfd);
// }


// void OnConnected(const PtrConnection &conn) {
//     DBG_LOG("NEW CONNECTION:%p", conn.get());
// }
// void OnClosed(const PtrConnection &conn) {
//     DBG_LOG("CLOSE CONNECTION:%p", conn.get());
// }
// void OnMessage(const PtrConnection &conn, Buffer *buf) {
//     DBG_LOG("%s", buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str = "Hello World";
//     conn->Send(str.c_str(), str.size());
// }
// int main()
// {
//     TcpServer server(8400);
//     server.SetThreadCount(2);
//     //server.EnableInactiveRelease(10);
//     server.SetClosedCallback(OnClosed);
//     server.SetConnectedCallback(OnConnected);
//     server.SetMessageCallback(OnMessage);
//     server.Start();
//     return 0;
// }


int main()
{
    TcpServer server(8400);
    server.SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));
    server.SetClosedCallback(std::bind(OnClosed,std::placeholders::_1));
    server.SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1));
    server.SetThreadCount(2);
    server.CreateTHreadPool();
    //server.EnableInactiveRelease(10);
    server.Start();

    return 0;
}


//Acceptor管理监听套接字
// int main()
// {
//     pool.SetThreadCount(2);
//     pool.Create();
//     //srand(time(nullptr));//随机任务id
//     //eventloop里面封装了epoll，用来对事件进行监控
//     Acceptor acceptor(&baseloop,8400);
//     // acceptor.SetAcceptCallback(std::bind(NewConnection,std::placeholders::_1));
//     // acceptor.Listen();
//     acceptor.SetAcceptorCallback(std::bind(NewConnection,std::placeholders::_1));
//     acceptor.Init();
//     baseloop.Start();
//     //sleep(1);
//     //lst_sock.Close();

//     return 0;
// }

//使用Connection管理套接字
//线程管理
// void NewConnection(int newfd){
//     conn_id++; 
//     next_thread=(next_thread+1)%2;
//     PtrConnection new_conn(new Connection(threads[next_thread].GetLoop(),conn_id,newfd));
//     // new_conn->SetMessageCallback(std::bind(OnMessage,new_conn,new_conn->InBuffer()));//,std::placeholders::_1));
//     // new_conn->SetClosedCallback(std::bind(ConnectionDestory,new_conn));
//     // new_conn->SetConnectedCallback(std::bind(OnConnected,new_conn));
//     //我们调用时都是自己传的参数，在这里不需要直接设定
//     new_conn->SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));
//     new_conn->SetClosedCallback(std::bind(ConnectionDestory,std::placeholders::_1));
//     new_conn->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1));
//     //new_conn->SetAnyEventCallback(std::bind(HandleEvent,new_conn));//任意事件回调都需要刷新时间
    
//     new_conn->EnableInactiveRelease(10);
//     new_conn->Established();//
//     _conns.insert(std::make_pair(conn_id,new_conn));
//     DEBUG_LOG("GET A NEW CONNECTION fd:%d",newfd);
// }


// //使用Connection管理套接字
// void Accepotr(EventLoop*loop,Channel*channel){
//     int fd=channel->Fd();
//     DEBUG_LOG("等待连接中");
//     int newfd=accept(fd,nullptr,nullptr);
//     if(newfd<0){
//         ERR_LOG("ACCEPT FAIL:%s",strerror(newfd));
//         std::cout<<"accept 错误"<<std::endl;
//         return ;
//     }

//     conn_id++; 
//     PtrConnection new_conn(new Connection(loop,conn_id,newfd));
//     DEBUG_LOG("新加入的连接 fd:%d",newfd);
//     // new_conn->SetMessageCallback(std::bind(OnMessage,new_conn,new_conn->InBuffer()));//,std::placeholders::_1));
//     // new_conn->SetClosedCallback(std::bind(ConnectionDestory,new_conn));
//     // new_conn->SetConnectedCallback(std::bind(OnConnected,new_conn));
//     //我们调用时都是自己传的参数，在这里不需要直接设定
//     new_conn->SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));//,std::placeholders::_1));
//     new_conn->SetClosedCallback(std::bind(ConnectionDestory,std::placeholders::_1));
//     new_conn->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1));
//     //new_conn->SetAnyEventCallback(std::bind(HandleEvent,new_conn));//任意事件回调都需要刷新时间
    
//     new_conn->EnableInactiveRelease(10);
//     new_conn->Established();//
//     _conns.insert(std::make_pair(conn_id,new_conn));
// }


//Socket管理监听套接字
// int main()
// {
//     srand(time(nullptr));//随机任务id
//     //eventloop里面封装了epoll，用来对事件进行监控
//     EventLoop loop;
//     Socket lst_sock;
//     lst_sock.CreateServer(8400);
//     //对监听套接字进行事件管理
//     Channel channel(&loop,lst_sock.Fd());
//     //设置回调函数获取新连接，为新连接创建Channel并且添加监控
//     channel.SetReadCallback(std::bind(Accepotr,&loop,&channel));
//     channel.EnableRead();
//     DEBUG_LOG("初始化完毕:%d",channel.Fd());
//     while(1){
//         loop.Start();
//         //sleep(1);
//     }
//     lst_sock.Close();

//     return 0;
// }


// void HandleClose(Channel*channel){
//     DEBUG_LOG("close %d",channel->Fd());
//     if(channel->Fd()>0){
//         channel->Remove();
//         channel->DisTriggerAl1();
//         delete channel;
//     }
// }

// void HandleRead(Channel*channel){
    
//      //给客户端回复数据
//     int fd=channel->Fd();
//     char buffer[1024]={0};
//     int n=recv(fd,buffer,1023,0);
//     //DEBUG_LOG("HandleRead,我被%d调用了",channel->Fd());
//     //连接断开是也会触发这个
//     if(n<0){
//         ERR_LOG("recv fail:%d,%s",channel->Fd(),strerror(n));
//         return HandleClose(channel);
//     }
//     DEBUG_LOG("%s",buffer);
//     //启动写监控
//     channel->EnableWrite();
// }

// void HandleWrite(Channel*channel){
//     int fd=channel->Fd();
//     const char*data="天气还不错哦！！！";
//     int n=send(fd,data,strlen(data),0);
//     if(n<0){
//         ERR_LOG("send fail:%d,%d",channel->Fd(),(n));
//         return HandleClose(channel);
//     }
//     channel->DisableWrite();
// }

// void HandleError(Channel*channel){
//     HandleClose(channel);
// }

// void HandleEvent(Channel*channel,EventLoop*loop,uint64_t timerid){
//     loop->TimerRefresh(timerid);
//     // DEBUG_LOG("HandleEvent,我被%d调用了",channel->Fd());
//     // std::cout<<"有一个事件触发了\n";
// }

//使用channel管理套接字
// void Accepotr(EventLoop*loop,Channel*channel){
//     int fd=channel->Fd();
//     DEBUG_LOG("等待连接中");
//     int newfd=accept(fd,nullptr,nullptr);
//     if(newfd<0){
//         ERR_LOG("ACCEPT FAIL:%s",strerror(newfd));
//         std::cout<<"accept 错误"<<std::endl;
//         return ;
//     }

//     uint64_t timerid=rand()%10000;
//     Channel*new_channel=new Channel(newfd,loop);
//     DEBUG_LOG("新加入的连接 fd:%d",newfd);
//     new_channel->SetReadCallback(std::bind(HandleRead,new_channel));
//     new_channel->SetWriteCallback(std::bind(HandleWrite,new_channel));
//     new_channel->SetErrorCallback(std::bind(HandleError,new_channel));
//     new_channel->SetCloseCallback(std::bind(HandleClose,new_channel));
//     new_channel->SetEventCallback(std::bind(HandleEvent,new_channel,loop,timerid));//任意事件回调都需要刷新时间

//     //非活跃超时连接销毁
//     //定时销毁任务，必须在启动读事件之前，因为有可能启动事件监控后，立即就有事件到来，无法刷新
//     loop->TimerAdd(timerid,10,std::bind(HandleClose,new_channel));
//     new_channel->EnableRead();
//     //HandleWrite(new_channel);
//     //new_channel->Enablewrite();
    
// }


// int main()
// {
//     srand(time(nullptr));//随机任务id
//     //eventloop里面封装了epoll，用来对事件进行监控
//     EventLoop loop;
//     Socket lst_sock;
//     lst_sock.CreateServer(8300);
//     //对监听套接字进行事件管理
//     Channel channel(lst_sock.Fd(),&loop);
//     //设置回调函数获取新连接，为新连接创建Channel并且添加监控
//     channel.SetReadCallback(std::bind(Accepotr,&loop,&channel));
//     channel.EnableRead();
//     DEBUG_LOG("初始化完毕:%d",channel.Fd());
//     while(1){
//         loop.Start();
//         //sleep(1);
//     }
//     //while(1){
//         // int newfd=lst_sock.Accept();
//         // if(newfd==-1){
//         //     continue;
//         // }
//         // std::cout<<newfd<<std::endl;
//         // Socket cli_sock(newfd);
//         // char buf[1024]={0};
//         // int ret=cli_sock.Recv(buf,1023);
//         // if(ret<0){
//         //     cli_sock.Close();
//         //     break;
//         // }
//         // cli_sock.Send(buf,1024);
//         // cli_sock.Close();
//     //}

//     lst_sock.Close();

//     return 0;
// }


//测试Poller模块
// int main()
// {
//     Poller poller;
//     Socket lst_sock;
//     lst_sock.createServer(8500);
//     //对监听套接字进行事件管理
//     Channel channel(lst_sock.Fd(),&poller);
//     //设置回调函数获取新连接，为新连接创建Channel并且添加监控
//     channel.SetReadCallback(std::bind(Accepotr,&poller,&channel));
//     channel.EnableRead();
//     DEBUG_LOG("初始化完毕:%d",channel.Fd());
//     while(1){
//         std::vector<Channel*> active;
//         poller.Poll(&active);
//         DEBUG_LOG("活跃事件数量：%d",active.size());
//         for(int i=0;i<active.size();i++){
//             active[i]->HandleEvent();
//         }
//         sleep(1);
//     }
//     //while(1){
//         // int newfd=lst_sock.Accept();
//         // if(newfd==-1){
//         //     continue;
//         // }
//         // std::cout<<newfd<<std::endl;
//         // Socket cli_sock(newfd);
//         // char buf[1024]={0};
//         // int ret=cli_sock.Recv(buf,1023);
//         // if(ret<0){
//         //     cli_sock.Close();
//         //     break;
//         // }
//         // cli_sock.Send(buf,1024);
//         // cli_sock.Close();
//     //}

//     lst_sock.Close();

//     return 0;
// }